package com.hfut.eeg.service;
import org.springframework.stereotype.Service;
import java.sql.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class tjf_DateBaoBiaoService {

    /*获取前端传来的时间段，按照年月日查询识别率，随机生成的
     *  Year
     *传入的参数是两个日期
     *因为要获取每年的日期，再根据每年获取识别率
     *首先获取起始时间，再对日期字符串进行分割
     * 获取年份，再对每年进行加 1 操作，再把字符串拼接成一个日期格式 yyyy-mm-dd
     */
    public List<Map<String, Object>> getRecognitionByYear(Date date1, Date date2) {
        //把日期类型转为字符串
        String s1 = date1.toString();
        String s2 = date2.toString();
        //对字符串进行分割
        String[] str1 = s1.split("-");
        String[] str2 = s2.split("-");
        List<Map<String, Object>> list = new ArrayList<>();
        //判断当前年份的开始年份，再根据每年获取识别率
        //返回一个list
        if (Integer.parseInt(str1[0]) < Integer.parseInt(str2[0])) {
            String Year = str1[0];
            Map<String, Object> map=new HashMap<>();
            //用Map来接收随机生成的数据
            Random rand = new Random();
            int count = rand.nextInt(10)+80;
            map.put("date", Year);
            map.put("recognition",count);
            list.add(map);
        }
        //判断中间是否隔有一整年的时间，如果有，再根据每年获取识别率
        int year = Integer.parseInt(str1[0]);
        /*
         * 用while循环，对日期进行判断
         * 对年份进行加一操作，并做判断
         * 分别获取每年的识别率，用Map来接收随机生成的数据
         * */
        while (year < (Integer.parseInt(str2[0]) - 1)) {
            year++;
            //整型转为字符串
            String y = Integer.toString(year);
            Map<String, Object> map = new HashMap<>();
            Random rand = new Random();
            int count = rand.nextInt(10)+80;
            //用Map来接收随机生成的数据
            map.put("date", y);
            map.put("recognition",count);
            list.add(map);
        }
        //判断前端传来的最后一年，再根据该年获取识别率
        String Year2 = str2[0];
        Map<String, Object> map = new HashMap<>();
        Random rand = new Random();
        int count = rand.nextInt(10)+80;
        //用Map来接收随机生成的数据
        map.put("date", Year2);
        map.put("recognition",count);
        list.add(map);
        return list;
    }
    /*
     * Month
     *获取前端传来的时间段，按照该时间获取识别率
     *获取前端传来的时间段，按照月份来查询整月识别率
     *传入的参数是两个日期
     *因为要获取每月的日期，再根据每月获取识别率
     *首先获取起始时间，再对日期字符串进行分割
     *获取每年的月份，再对每月进行加 1 操作，再把字符串拼接成一个日期格式 yyyy-mm-dd
     * */
    public List<Map<String, Object>> getRecognitionByMonth(Date date1,Date date2){
        //把日期类型转为字符串
        String s1 = date1.toString();
        String s2 = date2.toString();
        //对字符串进行分割操作
        String[] str1 = s1.split("-");
        String[] str2 = s2.split("-");
        List<Map<String, Object>> list = new ArrayList<>();

        //判断当前年份的开始月份，一直查询到12月的识别率
        if(Integer.parseInt(str1[0]) < Integer.parseInt(str2[0])){
            //获取起始日期的年份
            String Year = str1[0];
            int num = Integer.parseInt(str1[1]);
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到该年12月
             * 分别获取每个月的识别率，用Map来接收随机生成的数据
             * */
            while(num <= 12){
                String ss = Integer.toString(num);
                //System.out.println(Year+"-"+ss+"我是1");
                Map<String,Object> map = new HashMap<>();
                Random rand = new Random();
                int count = rand.nextInt(10)+80;
                String ss1 = Year+"-"+ss;
                //用Map来接收随机生成的数据
                map.put("date",ss1);
                map.put("recognition",count);
                list.add(map);
                //list.addAll(ordertableMapper.count4(Year,ss));
                num = num+1;
            }
        }
        //判断中间是否隔有一整年的时间，如果有，则查询该整年的每月的识别率
        int year = Integer.parseInt(str1[0]);
        /*
         * 用while循环判断中间是否隔有一整年的时间
         * 如果有，获取这一整年的日期
         * 对这一整年的12个月进行查询操作
         * 分别获取每个月的识别率，用Map来接收随机生成的数据
         * */
        while(year < (Integer.parseInt(str2[0])-1)){
            year++;
            String y = Integer.toString(year);
            int num = 1;
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到该年12月
             * 分别获取每个月的识别率，用Map来接收随机生成的数据
             * */
            while(num <= 12){
                String ss = Integer.toString(num);
                Map<String,Object> map = new HashMap<>();
                Random rand = new Random();
                int count = rand.nextInt(10)+80;
                String ss1 = y+"-"+ss;
                //用Map来接收随机生成的数据
                map.put("date",ss1);
                map.put("recognition",count);
                list.add(map);
                //list.addAll(ordertableMapper.count4(y,ss));
                num++;
            }
        }
        //判断前端传来的最后一年，从该年的一月份，查询到该年的截止月份
        String Year2 = str2[0];
        int m2 = Integer.parseInt(str2[1]);
        int num2 = 1;
        if(Integer.parseInt(str1[0])==Integer.parseInt(str2[0])){
            int m = Integer.parseInt(str1[1]);
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到最后一年的截止月份
             * 分别获取每个月的识别率，用Map来接收随机生成的数据
             * */
            while (m <= m2){
                String ss = Integer.toString(m);
                Map<String,Object> map = new HashMap<>();
                Random rand = new Random();
                int count = rand.nextInt(10)+80;
                ////拼接字符串
                String ss1 = Year2+"-"+ss;
                //用Map来接收随机生成的数据
                map.put("date",ss1);
                map.put("recognition",count);
                list.add(map);
                //list.addAll(ordertableMapper.count4(Year2,ss));
                m++;
            }
            return list;
        }else {
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到最后一年的截止月份
             * 分别获取每个月的识别率，用Map来接收随机生成的数据
             * */
            while(num2 <= m2){
                String ss = num2+" ";
                Map<String,Object> map = new HashMap<>();
                Random rand = new Random();
                int count = rand.nextInt(10)+80;
                ////拼接字符串
                String ss1 = Year2+"-"+ss;
                //用Map来接收随机生成的数据
                map.put("date",ss1);
                map.put("recognition",count);
                list.add(map);
                //list.addAll(ordertableMapper.count4(Year2,ss));
                num2++;
            }
            return list;
        }

    }
    /*
     * Day
     * 获取前端传来的时间段，按照该时间段查询每天的识别率
     *传入的参数是两个日期
     *因为要获取每天的日期，再根据每天获取识别率
     *首先获取起始时间，再对日期字符串进行分割
     *获取每天的具体日期，再对每天进行加 1 操作，再把字符串拼接成一个日期格式 yyyy-mm-dd
     * */
    public List<Map<String, Object>> getRecognitionByDay(Date date1,Date date2){
        //把日期格式转换为String
        String s1 = date1.toString();
        String s2 = date2.toString();
        //把字符串2019-11-30按 "-" 切割
        String[] str1 = s1.split("-");//把字符串2019-11-30按 "-" 切割
        String[] str2 = s2.split("-");
        List<Map<String, Object>> list = new ArrayList<>();
        //判断两个时间，是否是同一个年份
        if(Integer.parseInt(str1[0]) == Integer.parseInt(str2[0]) && Integer.parseInt(str1[1]) <= Integer.parseInt(str2[1])){
            String Year = str1[0];
            //把年份字符串转为整型
            int y1 = Integer.parseInt(str1[0]);
            //把月份字符串转为整型
            int m1 = Integer.parseInt(str1[1]);
            //把天数字符串转为整型
            int d1 = Integer.parseInt(str1[2]);
            //判断当前月份是否是同一个月，如果不是，则从前端传来的当前天的日期，查询到该月底
            if(m1 == Integer.parseInt(str2[1])) {
                //int转换为String
                String mm = Integer.toString(m1);
                /*
                 * 用while循环，对日期进行判断
                 * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
                 * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
                 * 分别获取每天的识别率，调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                 * */
                while (d1 <= Integer.parseInt(str2[2])) {
                    String dd = Integer.toString(d1);
                    //拼接字符串
                    String s4 = Year + "-" + mm + "-" + dd;
                    //调用createDate方法，创建日期
                    Date date3 = createDate(s4);
                    //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                    list.add(addDate(date3));
                    d1++;
                }
                return list;
            }
            //当两个日期不是同年的同一月时
            if(m1 < Integer.parseInt(str2[1])) {
                //int转换为String
                String mm = Integer.toString(m1);
                /*
                 * 用while循环，对日期进行判断
                 * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
                 * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
                 * 分别获取每天的识别率，调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                 * */
                while (d1 <= getDays(y1, m1)) {
                    String dd = Integer.toString(d1);
                    //拼接字符串
                    String s4 = Year + "-" + mm + "-" + dd;
                    //调用createDate方法，创建日期
                    Date date3 = createDate(s4);
                    //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                    list.add(addDate(date3));
                    d1++;
                }
                m1++;
            }

            //判断中间是否隔有整月，如果有，则查询该整月每天的人数
            /*
             * 用while循环，对日期进行判断
             * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
             * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
             * 分别获取每天的识别率，调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
             * */
            while(m1 < Integer.parseInt(str2[1])){
                String mm = Integer.toString(m1);
                //每月的第一天
                int i=1;
                while (i <= getDays(y1, m1)) {
                    String dd = Integer.toString(i);
                    String s4 = Year + "-" + mm + "-" + dd;
                    //调用createDate方法，创建日期
                    Date date3 = createDate(s4);
                    //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                    list.add(addDate(date3));
                    i++;
                }
                m1++;
            }
            //判断前端传来的截止月份，从该月第一天查询到该月的截止日期。
            int d2 = 1;
            String mm = Integer.toString(Integer.parseInt(str2[1]));
            /*
             * 用while循环，对日期进行判断
             * 获取天数，对天数进行加一操作，一直查询到该月的截止日期
             * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
             * 分别获取每天的识别率，调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
             * */
            while (d2 <= Integer.parseInt(str2[2])) {
                String dd = Integer.toString(d2);
                String s4 = Year + "-" + mm + "-" + dd;
                //调用createDate方法，创建日期
                Date date3 = createDate(s4);
                //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                list.add(addDate(date3));
                d2++;
            }

            return list;
        }

        //判断前端传来的第一个年份是否小于第二个年份
        if(Integer.parseInt(str1[0]) < Integer.parseInt(str2[0])){
            String Year = str1[0];
            //把年份字符串转为整型
            int y1 = Integer.parseInt(str1[0]);
            //把月份字符串转为整型
            int m1 = Integer.parseInt(str1[1]);
            //把天数字符串转为整型
            int d1 = Integer.parseInt(str1[2]);
            //从该月查询到12月，查询每天的识别率
            if(m1 <= 12) {
                //从当月的日期开始，查询到月底
                if(m1 == Integer.parseInt(str1[1])) {
                    //String mm = m1 + " ";
                    String mm = Integer.toString(m1);
                    /*
                     * 用while循环，对日期进行判断
                     * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
                     * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
                     * 分别获取每天的识别率，调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                     * */
                    while (d1 <= getDays(y1, m1)) {
                        String dd = Integer.toString(d1);
                        String s4 = Year + "-" + mm + "-" + dd;
                        //调用createDate方法，创建日期
                        Date date3 = createDate(s4);
                        //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                        list.add(addDate(date3));
                        d1++;
                    }
                    m1++;
                }
                //查询整月每天的人数
                while(m1 <= 12){
                    String mm = Integer.toString(m1);
                    int i=1;//每月的第一天
                    while (i <= getDays(y1, m1)) {
                        String dd = Integer.toString(i);
                        String s4 = Year + "-" + mm + "-" + dd;
                        //调用createDate方法，创建日期
                        Date date3 = createDate(s4);
                        //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                        list.add(addDate(date3));
                        i++;
                    }
                    m1++;
                }

            }
        }
        //判断中间是否隔有一整年的时间，如果有，则查询该整年的每天的识别率
        int y1 = Integer.parseInt(str1[0]);
        /*
         * 用while循环，对日期进行判断
         * 获取年份，对年份进行判断操作
         * 再获取该年的月份，对月份进行判断操作
         * 再获取该月的天数，将年月日拼接日期格式：yyyy-mm-dd
         * 分别获取每天的识别率，调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
         * 再对天进行加一操作，查询完该月的天数之后，再对月进行加一操作，月份查询完之后，再对年份加一操作查询
         * */
        while(y1 < (Integer.parseInt(str2[0])-1)){
            y1++;
            //System.out.println(y1+"#########################");
            String yy = Integer.toString(y1);
            int m1 = 1;
            while(m1 <= 12) {
                int d1 = 1;
                String mm = Integer.toString(m1);
                while (d1 <= getDays(y1, m1)) {
                    String dd = Integer.toString(d1);
                    String s4 = yy + "-" + mm + "-" + dd;
                    //调用createDate方法，创建日期
                    Date date3 = createDate(s4);
                    //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                    list.add(addDate(date3));
                    d1++;
                }
                m1++;
                //System.out.println(m1);
            }
        }
        /*
         * 判断前端传来的最后一年
         * 从该年的一月份
         * 查询到该年的截止月份的每天识别率
         * */
        String yy2 = str2[0];
        int y2 =  Integer.parseInt(str2[0]);
        int month = Integer.parseInt(str2[1]);
        int m2 = 1;

        //判断是否小于月份，查询整月的识别率
        while(m2 < month) {
            // String mm2 = m2;
            int d2 = 1;
            String mm2 = Integer.toString(m2);
            while (d2 <= getDays(y2, m2)) {
                //String dd2 = d2 + " ";
                String dd2 = Integer.toString(d2);
                String s4 = yy2 + "-" + mm2 + "-" + dd2;
                //调用createDate方法，创建日期
                Date date3 = createDate(s4);
                //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                list.add(addDate(date3));
                d2++;
            }
            m2++;
        }
        /*
         * 判断截止月份
         * 从该月1号查询到该月的截止日期
         * */
        if(m2== month){
            int d3 = 1;
            while (d3 <= Integer.parseInt(str2[2])) {
                //String dd2 = d2 + " ";
                String mm2 = Integer.toString(m2);
                String dd2 = Integer.toString(d3);
                String s4 = yy2 + "-" + mm2 + "-" + dd2;
                //调用createDate方法，创建日期
                Date date3 = createDate(s4);
                //调用addDate方法，根据日期查询该天的识别率，添加该天的日期和识别率到map集合中
                list.add(addDate(date3));
                d3++;
            }
        }
        return list;
    }

    /*
     * 根据年月获得该月的天数
     * swith操作，获取该月具体的天数
     * */
    public static int getDays(int year, int month) {
        int days = 0;
        boolean isLeapYear = false;
        if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
            isLeapYear = true;
        } else {
            isLeapYear = false;
        }
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                days = 31;
                break;
            case 2:
                if (isLeapYear) {
                    days = 29;
                } else {
                    days = 28;
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                days = 30;
                break;
            default:
                System.out.println("error!!!");
                break;
        }
        return days;
    }
    /*
     * 传入日期参数
     * 查询数据并添加该日期到map集合中
     * 返回map集合
     * */
    public Map<String,Object> addDate(Date date3){
        Map<String,Object> map = new HashMap<>();
        Random rand = new Random();
        int count = rand.nextInt(10)+80;
        String ss1 = date3.toString();
        map.put("date",ss1);
        map.put("recognition",count);
        return map;
    }
    /*
     * 根据传入的字符串，创建日期
     * */
    public Date createDate(String s4){
        DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
        java.util.Date date = null;
        java.sql.Date date3 = null;
        try {
            //把字符串2019-11-30转换为日期格式
            date = format1.parse(s4);
            //把java.util.Date date转换为java.sql.Date
            date3 = new java.sql.Date(date.getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date3;
    }
}
